
(defvar lisp-mode-syntax-table nil "")

(defvar lisp-mode-abbrev-table nil "")

(if (not lisp-mode-syntax-table) (let ((i 0)) (setq lisp-mode-syntax-table (make-syntax-table)) (set-syntax-table lisp-mode-syntax-table) (while (< i 48) (modify-syntax-entry i "_   ") (setq i (1+ i))) (setq i (1+ 57)) (while (< i 65) (modify-syntax-entry i "_   ") (setq i (1+ i))) (setq i (1+ 90)) (while (< i 97) (modify-syntax-entry i "_   ") (setq i (1+ i))) (setq i (1+ 122)) (while (< i 128) (modify-syntax-entry i "_   ") (setq i (1+ i))) (modify-syntax-entry 32 "    ") (modify-syntax-entry 9 "    ") (modify-syntax-entry 10 ">   ") (modify-syntax-entry 12 ">   ") (modify-syntax-entry 59 "<   ") (modify-syntax-entry 96 "'   ") (modify-syntax-entry 39 "'   ") (modify-syntax-entry 44 "'   ") (modify-syntax-entry 46 "'   ") (modify-syntax-entry 35 "'   ") (modify-syntax-entry 34 "\"    ") (modify-syntax-entry 92 "\\   ") (modify-syntax-entry 40 "()  ") (modify-syntax-entry 41 ")(  ")))

(define-abbrev-table (quote lisp-mode-abbrev-table) nil)

(defun lisp-mode-variables nil (byte-code "�!�
����!��P����!�����!�Ή���!�ω���!�Љ���!�щ	���!�҉
�" [lisp-mode-syntax-table local-abbrev-table lisp-mode-abbrev-table paragraph-start page-delimiter paragraph-separate indent-line-function comment-start comment-start-skip comment-column comment-indent-hook set-syntax-table make-local-variable "^$\\|" lisp-indent-line ";" ";+ *" 40 lisp-comment-indent] 18))

(defun lisp-mode-commands (map) (byte-code "���#����#����#�" [map define-key "" indent-sexp "" backward-delete-char-untabify "	" lisp-indent-line] 6))

(defvar emacs-lisp-mode-map nil "")

(defun emacs-lisp-mode nil "\
Major mode for editing Lisp code to run in Emacs.
Commands:
Delete converts tabs to spaces as it moves back.
\\[lisp-indent-line] indents for Lisp; with argument, shifts rest
 of expression rigidly with the current line.
\\[indent-sexp] does Tab on each line starting within following expression.
\\[eval-defun] evaluates the largest Lisp expression around or after dot.
Blank lines separate paragraphs.  Semicolons start comments.

Entry to this mode calls the value of emacs-lisp-mode-hook
if that value is non-nil." (interactive) (byte-code "Ĉ� �?� � �����#��!� Ĉ�!�̉�͉�� ���!�9 �9 �!�" [emacs-lisp-mode-map major-mode mode-name emacs-lisp-mode-hook nil kill-all-local-variables make-sparse-keymap define-key "" eval-defun lisp-mode-commands use-local-map emacs-lisp-mode "Emacs-Lisp" lisp-mode-variables boundp funcall] 16))

(defvar lisp-mode-map nil)

(defun lisp-mode nil "\
Major mode for editing Lisp code for Lisps other than GNU Emacs Lisp.
Commands:
Delete converts tabs to spaces as it moves back.
\\[lisp-indent-line] indents for Lisp; with argument, shifts rest
 of expression rigidly with the current line.
\\[indent-sexp] does Tab on each line starting within following expression.
\\[lisp-send-defun] sends the top-level expression around or after dot
 to the subprocess named `lisp'.
Blank lines separate paragraphs.  Semicolons start comments.

Entry to this mode calls the value of lisp-mode-hook
if that value is non-nil." (interactive) (byte-code "Ĉ� �?� � �����#��!� Ĉ�!�̉�͉�� ���!�9 �9 �!�" [lisp-mode-map major-mode mode-name lisp-mode-hook nil kill-all-local-variables make-sparse-keymap define-key "" lisp-send-defun lisp-mode-commands use-local-map lisp-mode "Lisp" lisp-mode-variables boundp funcall] 16))

(defun lisp-send-defun nil "\
Send the current defun to the Lisp process made by M-x run-lisp." (interactive) (byte-code "����!�" [nil error "Process lisp does not exist"] 3))

(defvar lisp-interaction-mode-map nil)

(defun lisp-interaction-mode nil "\
Major mode for typing and evaluating Lisp forms.
Like Lisp mode except that \\[eval-print-last-sexp] evals the Lisp expression
before dot, and prints its value into the buffer, advancing dot.

Commands:
\\[eval-print-last-sexp] as above.
Delete converts tabs to spaces as it moves back.
\\[lisp-indent-line] indents for Lisp; with argument, shifts rest
 of expression rigidly with the current line.
\\[indent-sexp] does Tab on each line starting within following expression.
\\[eval-defun] evaluates the largest Lisp expression around or after dot.
Paragraphs are separated only by blank lines.  Semicolons start comments.

Entry to this mode calls the value of lisp-interaction-mode-hook
if that value is non-nil." (interactive) (byte-code "Ĉ� �?�! � ���!����#����#�\" Ĉ�!�Ή�ω�� ���!�? �? �!�" [lisp-interaction-mode-map major-mode mode-name lisp-interaction-mode-hook nil kill-all-local-variables make-sparse-keymap lisp-mode-commands define-key "" eval-defun "
" eval-print-last-sexp use-local-map lisp-interaction-mode "Lisp Interaction" lisp-mode-variables boundp funcall] 17))

(defun eval-print-last-sexp (arg) "\
Evaluate sexp before point; print value into current buffer." (interactive "P") (byte-code "�� Ŏ��	!���!�`)))`p#�" [stab lisp-mode-syntax-table nil eval-region syntax-table ((byte-code "�!�" [stab set-syntax-table] 3)) set-syntax-table forward-sexp -1] 12))

(defun lisp-comment-indent nil (byte-code "��!�
 i�* ��!�\" � <� @� )�* ��!�iT	]�" [tem comment-column looking-at ";;;" ";;" calculate-lisp-indent skip-chars-backward " 	"] 14))

(defconst lisp-indent-offset nil "")

(defconst lisp-indent-hook (quote lisp-indent-hook) "")

(defun lisp-indent-line (&optional whole-exp) "\
Indent current line as Lisp code.
With argument, indent any additional lines of the same expression
rigidly along with this one." (interactive "P") (byte-code "ň� ���d`Z� �`����!���!�$ �� <�0 @��1 ňiZ���	!�B �I �
`\"�j�dZ`V�Y dZb�Z ň�� �	!?�� �
b���!�`��
b���!�`��
V)�� �
	#-�" [indent shift-amt beg end pos nil whole-exp calculate-lisp-indent beginning-of-line skip-chars-forward " 	" looking-at "[ 	]*;;;" zerop delete-region forward-sexp 1 forward-line indent-code-rigidly] 28))

(defun calculate-lisp-indent (&optional parse-start) "\
Return appropriate indentation for current line as Lisp code.
In usual case returns an integer: the column to indent to.
Can instead return a list, whose car is the column to indent to.
This means that following lines at the same level of indentation
should not necessarily be indented the same way.
The second element of the list is the buffer position
of the start of the containing expression." (byte-code "�� �`������ b�! � �`W�3 �`�#���\" ��B 	@��B 
�V�%	���	8��	A@��Tb��f `V�� ��#

A@��� 
��� �)�� Ɉ?� Tb�?�� i���`�$���!�� ���!�`)V?�� b�� ��`�$�� Ɉ� �i�����!�`)V��`�$��`\"���!��`�$�Ɉ� ��b�� ��`�$�� �!Ɉ�4 ���	\"@�;b���!�i��r�!�D�Tb�i\\��r�k��!�k?�k�	#�?�ri��.)�" [indent-point state paren-depth desired-indent retry t last-sexp containing-sexp parse-start nil peek lisp-indent-offset lisp-indent-hook beginning-of-line beginning-of-defun parse-partial-sexp 0 2 looking-at "\\s(" forward-line 1 backward-prefix-chars /= forward-sexp nthcdr 3 skip-chars-forward " 	" integerp fboundp funcall] 70))

(defun lisp-indent-hook (indent-point state) (byte-code "i�	A@Tb���!��`	A@\"�o ���!�`��!�`\"��
!�N���=�F ?�F 
G�V�F �
��O�\"�P �	\"�k �!�^ �	#�k �j �	#�k �*�p �))�" [normal-indent state function method indent-point re-search-forward "\\sw\\|\\s_" /= buffer-substring forward-char -1 forward-sexp 1 nil intern-soft lisp-indent-hook defun 3 string-equal 0 "def" lisp-indent-defform integerp lisp-indent-specform funcall] 29))

(defconst lisp-body-indent 2 "")

(defun lisp-indent-specform (count state indent-point) (byte-code "	A@��b�i��\\����!���!��`�$�`W�4 ��Џ�< Ɉ�) ��V�^ 
Z�X�W ��\"\\D�[ 
D�} 
�U�g �U�t �U�t 
X�{ �} 
,�" [containing-form-start state i count body-indent containing-form-column lisp-body-indent indent-point t nil normal-indent forward-char 1 forward-sexp parse-partial-sexp (byte-code "S����!��`	�
$�" [count indent-point t forward-sexp 1 parse-partial-sexp] 7) ((error (byte-code "�" [nil] 2))) 0 * 2] 23))

(defun lisp-indent-defform (state indent-point) (byte-code "A@b���!�`AA@V� A@b�	i\\� ć" [state lisp-body-indent forward-line 1 nil] 5))

(put (quote lambda) (quote lisp-indent-hook) (quote defun))

(put (quote progn) (quote lisp-indent-hook) 0)

(put (quote prog1) (quote lisp-indent-hook) 1)

(put (quote save-excursion) (quote lisp-indent-hook) 0)

(put (quote save-window-excursion) (quote lisp-indent-hook) 0)

(put (quote save-restriction) (quote lisp-indent-hook) 0)

(put (quote let) (quote lisp-indent-hook) 1)

(put (quote let*) (quote lisp-indent-hook) 1)

(put (quote while) (quote lisp-indent-hook) 1)

(put (quote if) (quote lisp-indent-hook) 2)

(put (quote catch) (quote lisp-indent-hook) 1)

(put (quote condition-case) (quote lisp-indent-hook) 2)

(put (quote unwind-protect) (quote lisp-indent-hook) 1)

(put (quote with-output-to-temp-buffer) (quote lisp-indent-hook) 1)

(defun indent-sexp nil "\
Indent each line of the list starting just after dot." (interactive) (byte-code "��	C���������!)��	��?�2
	�	�	?�5 m�?�� �`� �`		%��@����\"@�g � �� ����\"	\"�h ����\"@�x ��!�} 
�	��+ �
�X��� 	�.
V�� AS���� �
W�� �BT���� ���!�`����!�m�� ��!�� 	�.@�� @�Y�� @���@�� @[�� �!�!�	��\"��A@[\"�@�)��i\"�-�`\"�j�.��� ).�" [indent-stack nil next-depth bol outer-loop-done inner-loop-done state this-indent last-depth innerloop-done t val 0 forward-sexp 1 parse-partial-sexp end-of-line nthcdr 4 indent-for-comment setcar 3 forward-line skip-chars-forward " 	" looking-at "[;
]" calculate-lisp-indent integerp /= delete-region] 63))

(defun indent-code-rigidly (start end arg &optional nochange-regexp) "\
Indent all lines of code, starting in the region, sideways by ARG columns.
Does not affect lines starting inside comments or strings,
assuming that the start of the region is not inside them.
Called from a program, takes args START, END, COLUMNS and NOCHANGE-REGEXP.
The last is a regexp which, if matched at the beginning of a line,
means don't indent that line." (interactive "r
p") (byte-code "È��	b�� ��
b�n�! �`��!�`%��`	W�f ��\"@�T �7 �!�T � �`��!�`\"�l�S ��\\]�\")��`��!�`%���\" ))�" [state end start nil nochange-regexp indent arg dot-marker parse-partial-sexp forward-line 1 nthcdr 3 looking-at current-indentation delete-region skip-chars-forward " 	" indent-to 0] 27))
